from flask import Blueprint, request, jsonify, current_app
from flask_jwt_extended import jwt_required, get_jwt_identity
from flasgger import swag_from
from datetime import datetime, timedelta
from sqlalchemy import func, and_, or_, text
from app import db
from app.models.activity import Activity, ActivityParticipant
from app.models.user import User
from app.models.venue import Venue, VenueTimeSlot
from app.models.user_relation import UserRelation
from app.models.order import Order
from app.utils.decorators import admin_required
from app.utils.response import success_response, error_response
# 移除外部文档导入，改为内联定义
# from app.api.v1.docs.activity_docs import ADMIN_GET_ACTIVITIES_DOC
import json
import time

activity_management_bp = Blueprint('activity_management', __name__)

@activity_management_bp.route('/activities', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '获取活动列表',
    'description': '🔐 需要管理员Token认证 - 管理员获取活动列表，支持分页、搜索和筛选',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 10,
            'description': '每页数量'
        },
        {
            'name': 'keyword',
            'in': 'query',
            'type': 'string',
            'description': '搜索关键词'
        },
        {
            'name': 'status',
            'in': 'query',
            'type': 'string',
            'description': '活动状态筛选'
        },
        {
            'name': 'venue_id',
            'in': 'query',
            'type': 'integer',
            'description': '场馆ID筛选'
        }
    ],
    'responses': {
        200: {
            'description': '获取活动列表成功。返回分页的活动数据，包含活动基本信息、组织者信息、场馆信息、参与人数统计等。',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'activities': {
                                'type': 'array',
                                'description': '活动列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer', 'description': '活动ID'},
                                        'title': {'type': 'string', 'description': '活动标题'},
                                        'description': {'type': 'string', 'description': '活动描述'},
                                        'organizer_name': {'type': 'string', 'description': '组织者姓名'},
                                        'venue_name': {'type': 'string', 'description': '场馆名称'},
                                        'start_time': {'type': 'string', 'description': '开始时间'},
                                        'end_time': {'type': 'string', 'description': '结束时间'},
                                        'max_participants': {'type': 'integer', 'description': '最大参与人数'},
                                        'participant_count': {'type': 'integer', 'description': '当前参与人数'},
                                        'status': {'type': 'string', 'description': '活动状态'},
                                        'activity_type': {'type': 'string', 'description': '活动类型'},
                                        'is_free': {'type': 'boolean', 'description': '是否免费'},
                                        'fee': {'type': 'number', 'description': '费用'},
                                        'fee_description': {'type': 'string', 'description': '费用说明'},
                                        'contact_info': {'type': 'string', 'description': '联系方式'},
                                        'allow_waitlist': {'type': 'boolean', 'description': '是否允许候补'},
                                        'is_active': {'type': 'boolean', 'description': '是否激活'},
                                        'images': {'type': 'array', 'items': {'type': 'string'}, 'description': '活动图片'},
                                        'created_at': {'type': 'string', 'description': '创建时间'},
                                        'updated_at': {'type': 'string', 'description': '更新时间'}
                                    }
                                }
                            },
                            'total': {'type': 'integer', 'description': '总记录数'},
                            'page': {'type': 'integer', 'description': '当前页码'},
                            'pages': {'type': 'integer', 'description': '总页数'},
                            'per_page': {'type': 'integer', 'description': '每页数量'}
                        }
                    }
                }
            },
            'examples': {
                'application/json': {
                    'code': 200,
                    'message': '获取成功',
                    'data': {
                        'activities': [
                            {
                                'id': 23,
                                'title': '网球双打技巧训练',
                                'description': '网球双打技巧训练，提升配合默契',
                                'organizer_id': 1,
                                'organizer_name': '管理员',
                                'venue_id': 1,
                                'venue_name': '网球场A',
                                'start_time': '2025-06-25 10:00:00',
                                'end_time': '2025-06-25 12:00:00',
                                'max_participants': 20,
                                'current_participants': 8,
                                'participant_count': 8,
                                'status': 'open',
                                'activity_type': 'training',
                                'is_free': True,
                                'fee': 0.0,
                                'fee_description': '免费参与',
                                'contact_info': '13800138000',
                                'allow_waitlist': True,
                                'is_active': True,
                                'images': ['/static/images/default-activity.jpg'],
                                'created_at': '2025-06-16 16:42:18',
                                'updated_at': '2025-06-16 16:42:18'
                            }
                        ],
                        'total': 25,
                        'page': 1,
                        'pages': 3,
                        'per_page': 10
                    }
                }
            }
        },
        401: {
            'description': '未授权访问',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 401},
                    'message': {'type': 'string', 'example': '未授权访问'}
                }
            }
        },
        500: {
            'description': '服务器内部错误',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 500},
                    'message': {'type': 'string', 'example': '获取失败'}
                }
            }
        }
    }
})
def get_activities():
    """获取活动列表"""
    try:
        # 获取查询参数
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 10, type=int), 100)
        keyword = request.args.get('keyword', '')
        status = request.args.get('status', '')
        venue_id = request.args.get('venue_id', type=int)
        start_date = request.args.get('start_date', '')
        end_date = request.args.get('end_date', '')
        
        # 构建查询
        query = Activity.query
        
        # 关键词搜索
        if keyword:
            query = query.filter(Activity.title.contains(keyword))
        
        # 状态筛选
        if status:
            query = query.filter(Activity.status == status)
        
        # 场馆筛选
        if venue_id:
            query = query.filter(Activity.venue_id == venue_id)
        
        # 时间范围筛选
        if start_date:
            try:
                start_datetime = datetime.strptime(start_date, '%Y-%m-%d')
                query = query.filter(Activity.start_time >= start_datetime)
            except ValueError:
                pass
        
        if end_date:
            try:
                end_datetime = datetime.strptime(end_date, '%Y-%m-%d') + timedelta(days=1)
                query = query.filter(Activity.start_time < end_datetime)
            except ValueError:
                pass
        
        # 排序
        query = query.order_by(Activity.created_at.desc())
        
        # 分页
        pagination = query.paginate(
            page=page, 
            per_page=per_page, 
            error_out=False
        )
        
        activities = []
        for activity in pagination.items:
            activity_data = activity.to_dict(include_organizer=True)
            # 添加场馆信息
            if activity.venue:
                activity_data['venue'] = activity.venue.to_dict()
            # 添加参与人数统计
            participant_count = ActivityParticipant.query.filter_by(
                activity_id=activity.id, status='joined'
            ).count()
            activity_data['participant_count'] = participant_count
            activities.append(activity_data)
        
        return jsonify({
            'code': 200,
            'message': '获取成功',
            'data': {
                'activities': activities,
                'total': pagination.total,
                'page': page,
                'per_page': per_page,
                'pages': pagination.pages
            }
        })
        
    except Exception as e:
        current_app.logger.error(f"获取活动列表失败: {str(e)}")
        return jsonify({'code': 500, 'message': '获取失败'}), 500


@activity_management_bp.route('/activities/<int:activity_id>', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '获取活动详情',
    'description': '🔐 需要管理员Token认证 - 管理员获取指定活动的详细信息',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'activity_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '活动ID'
        }
    ],
    'responses': {
        200: {
            'description': '获取活动详情成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'id': {'type': 'integer', 'description': '活动ID', 'example': 23},
                            'title': {'type': 'string', 'description': '活动标题', 'example': '网球双打技巧训练'},
                            'description': {'type': 'string', 'description': '活动描述'},
                            'start_time': {'type': 'string', 'description': '开始时间', 'example': '2025-06-25 10:00:00'},
                            'end_time': {'type': 'string', 'description': '结束时间', 'example': '2025-06-25 12:00:00'},
                            'venue': {
                                'type': 'object',
                                'description': '场馆信息',
                                'properties': {
                                    'id': {'type': 'integer', 'example': 1},
                                    'name': {'type': 'string', 'example': '网球场A'},
                                    'location': {'type': 'string', 'example': '主馆1层'}
                                }
                            },
                            'participants': {
                                'type': 'array',
                                'description': '参与者列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'user': {'type': 'object'},
                                        'joined_at': {'type': 'string'},
                                        'status': {'type': 'string'}
                                    }
                                }
                            },
                            'participant_count': {'type': 'integer', 'description': '当前参与人数', 'example': 8},
                            'max_participants': {'type': 'integer', 'description': '最大参与人数', 'example': 20},
                            'status': {'type': 'string', 'description': '活动状态', 'example': 'open'}
                        }
                    }
                }
            }
        },
        404: {
            'description': '活动不存在',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 404},
                    'message': {'type': 'string', 'example': '活动不存在'}
                }
            }
        }
    }
})
def get_activity_detail(activity_id):
    """获取活动详情"""
    try:
        activity = Activity.query.get_or_404(activity_id)
        
        # 获取活动详细信息
        activity_data = activity.to_dict(include_organizer=True)
        
        # 添加场馆信息
        if activity.venue:
            activity_data['venue'] = activity.venue.to_dict()
        
        # 添加参与者列表
        participants = []
        for participant in ActivityParticipant.query.filter_by(
            activity_id=activity_id, status='joined'
        ).all():
            if participant.user:
                participants.append({
                    'id': participant.id,
                    'user': participant.user.to_dict(),
                    'joined_at': participant.joined_at.strftime('%Y-%m-%d %H:%M:%S') if participant.joined_at else None,
                    'status': participant.status
                })
        
        activity_data['participants'] = participants
        activity_data['participant_count'] = len(participants)
        
        return jsonify({
            'code': 200,
            'message': '获取成功',
            'data': activity_data
        })
        
    except Exception as e:
        current_app.logger.error(f"获取活动详情失败: {str(e)}")
        return jsonify({'code': 500, 'message': '获取失败'}), 500


@activity_management_bp.route('/activities', methods=['POST'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '创建活动',
    'description': '🔐 需要管理员Token认证 - 管理员创建新活动',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['title', 'organizer_id', 'start_time', 'end_time'],
                'properties': {
                    'title': {'type': 'string', 'description': '活动标题'},
                    'description': {'type': 'string', 'description': '活动描述'},
                    'organizer_id': {'type': 'integer', 'description': '组织者用户ID'},
                    'venue_id': {'type': 'integer', 'description': '场馆ID'},
                    'start_time': {'type': 'string', 'description': '开始时间（YYYY-MM-DD HH:MM:SS）'},
                    'end_time': {'type': 'string', 'description': '结束时间（YYYY-MM-DD HH:MM:SS）'},
                    'venue_start_time': {'type': 'string', 'description': '场馆预订开始时间（YYYY-MM-DD HH:MM:SS）'},
                    'venue_end_time': {'type': 'string', 'description': '场馆预订结束时间（YYYY-MM-DD HH:MM:SS）'},
                    'max_participants': {'type': 'integer', 'description': '最大参与人数'},
                    'images': {'type': 'array', 'items': {'type': 'string'}, 'description': '活动图片URL列表'},
                    'status': {'type': 'string', 'enum': ['open', 'closed'], 'description': '状态'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '创建活动成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '活动创建成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'id': {'type': 'integer', 'description': '新创建的活动ID', 'example': 24},
                            'title': {'type': 'string', 'description': '活动标题', 'example': '网球双打技巧训练'},
                            'status': {'type': 'string', 'description': '活动状态', 'example': 'open'},
                            'created_at': {'type': 'string', 'description': '创建时间', 'example': '2025-06-20 16:30:00'}
                        }
                    }
                }
            }
        },
        400: {
            'description': '参数错误',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 400},
                    'message': {'type': 'string', 'example': '参数错误：标题不能为空'}
                }
            }
        }
    }
})
def create_activity():
    """创建活动"""
    try:
        data = request.get_json()
        
        # 验证必要参数
        required_fields = ['title', 'organizer_id', 'start_time', 'end_time']
        for field in required_fields:
            if not data.get(field):
                return jsonify({'code': 400, 'message': f'缺少必要参数: {field}'}), 400
        
        # 验证组织者是否存在
        organizer = User.query.get(data['organizer_id'])
        if not organizer:
            return jsonify({'code': 400, 'message': '组织者不存在'}), 400
        
        # 验证场馆是否存在（如果提供了场馆ID）
        venue = None
        venue_id = data.get('venue_id')
        if venue_id:
            venue = Venue.query.get(venue_id)
            if not venue:
                return jsonify({'code': 400, 'message': '场馆不存在'}), 400
        
        # 解析时间
        try:
            start_time = datetime.strptime(data['start_time'], '%Y-%m-%d %H:%M:%S')
            end_time = datetime.strptime(data['end_time'], '%Y-%m-%d %H:%M:%S')
        except ValueError:
            return jsonify({'code': 400, 'message': '时间格式错误，请使用 YYYY-MM-DD HH:MM:SS 格式'}), 400
        
        # 解析场馆预订时间（可选）
        venue_start_time = None
        venue_end_time = None
        if data.get('venue_start_time'):
            try:
                venue_start_time = datetime.strptime(data['venue_start_time'], '%Y-%m-%d %H:%M:%S')
            except ValueError:
                return jsonify({'code': 400, 'message': '场馆开始时间格式错误'}), 400
        
        if data.get('venue_end_time'):
            try:
                venue_end_time = datetime.strptime(data['venue_end_time'], '%Y-%m-%d %H:%M:%S')
            except ValueError:
                return jsonify({'code': 400, 'message': '场馆结束时间格式错误'}), 400
        
        # 验证时间逻辑
        if start_time >= end_time:
            return jsonify({'code': 400, 'message': '开始时间必须早于结束时间'}), 400
        
        if start_time <= datetime.now():
            return jsonify({'code': 400, 'message': '开始时间必须晚于当前时间'}), 400
        
        # 验证场馆预订时间逻辑
        if venue_start_time and venue_end_time:
            if venue_start_time >= venue_end_time:
                return jsonify({'code': 400, 'message': '场馆预订开始时间必须早于结束时间'}), 400
        
        # 验证最大参与人数
        max_participants = data.get('max_participants', 20)
        if venue and venue.max_capacity:
            if max_participants > venue.max_capacity:
                return jsonify({
                    'code': 400, 
                    'message': f'最大参与人数不能超过场馆容量（{venue.max_capacity}人）'
                }), 400
        
        # 如果选择了场馆且设置了场馆使用时间，检查时间段冲突
        if venue and venue_start_time and venue_end_time:
            conflicting_activities = Activity.query.filter(
                Activity.venue_id == venue_id,
                Activity.status.in_(['open', 'closed']),  # 排除已取消的活动
                db.or_(
                    # 活动开始时间在查询时间段内
                    db.and_(Activity.venue_start_time >= venue_start_time, Activity.venue_start_time < venue_end_time),
                    # 活动结束时间在查询时间段内
                    db.and_(Activity.venue_end_time > venue_start_time, Activity.venue_end_time <= venue_end_time),
                    # 活动时间段包含查询时间段
                    db.and_(Activity.venue_start_time <= venue_start_time, Activity.venue_end_time >= venue_end_time)
                )
            ).first()
            
            if conflicting_activities:
                return jsonify({
                    'code': 400, 
                    'message': f'场馆在该时间段已被活动"{conflicting_activities.title}"占用'
                }), 400
        
        # 处理图片
        images = data.get('images', [])
        if not images:
            # 如果没有上传图片，使用默认图片
            images = ['/static/images/default-activity.jpg']
        
        # 创建活动
        activity = Activity(
            title=data['title'],
            description=data.get('description', ''),
            organizer_id=data['organizer_id'],
            venue_id=venue_id,
            start_time=start_time,
            end_time=end_time,
            venue_start_time=venue_start_time,
            venue_end_time=venue_end_time,
            max_participants=max_participants,
            images=json.dumps(images),
            status=data.get('status', 'open')
        )
        
        db.session.add(activity)
        db.session.commit()
        
        return jsonify({
            'code': 200,
            'message': '创建成功',
            'data': activity.to_dict(include_organizer=True)
        })
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"创建活动失败: {str(e)}")
        return jsonify({'code': 500, 'message': '创建失败'}), 500


@activity_management_bp.route('/activities/<int:activity_id>', methods=['PUT'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '更新活动',
    'description': '🔐 需要管理员Token认证 - 管理员更新活动信息',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'activity_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '活动ID'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'properties': {
                    'title': {'type': 'string', 'description': '活动标题'},
                    'description': {'type': 'string', 'description': '活动描述'},
                    'venue_id': {'type': 'integer', 'description': '场馆ID'},
                    'start_time': {'type': 'string', 'description': '开始时间'},
                    'end_time': {'type': 'string', 'description': '结束时间'},
                    'max_participants': {'type': 'integer', 'description': '最大参与人数'},
                    'status': {'type': 'string', 'enum': ['open', 'closed', 'cancelled'], 'description': '状态'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '更新活动成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '更新成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'id': {'type': 'integer', 'description': '活动ID'},
                            'title': {'type': 'string', 'description': '活动标题'},
                            'status': {'type': 'string', 'description': '活动状态'},
                            'updated_at': {'type': 'string', 'description': '更新时间'}
                        }
                    }
                }
            }
        },
        404: {
            'description': '活动不存在',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 404},
                    'message': {'type': 'string', 'example': '活动不存在'}
                }
            }
        }
    }
})
def update_activity(activity_id):
    """更新活动"""
    try:
        activity = Activity.query.get_or_404(activity_id)
        data = request.get_json()
        
        # 更新字段
        if 'title' in data:
            activity.title = data['title']
        
        if 'description' in data:
            activity.description = data['description']
        
        if 'venue_id' in data:
            venue_id = data['venue_id']
            if venue_id:
                venue = Venue.query.get(venue_id)
                if not venue:
                    return jsonify({'code': 400, 'message': '场馆不存在'}), 400
            activity.venue_id = venue_id
        
        if 'start_time' in data:
            try:
                activity.start_time = datetime.strptime(data['start_time'], '%Y-%m-%d %H:%M:%S')
            except ValueError:
                return jsonify({'code': 400, 'message': '开始时间格式错误'}), 400
        
        if 'end_time' in data:
            try:
                activity.end_time = datetime.strptime(data['end_time'], '%Y-%m-%d %H:%M:%S')
            except ValueError:
                return jsonify({'code': 400, 'message': '结束时间格式错误'}), 400
        
        if 'max_participants' in data:
            activity.max_participants = data['max_participants']
        
        if 'status' in data:
            activity.status = data['status']
        
        # 验证时间逻辑
        if activity.start_time >= activity.end_time:
            return jsonify({'code': 400, 'message': '开始时间必须早于结束时间'}), 400
        
        activity.updated_at = datetime.now()
        db.session.commit()
        
        return jsonify({
            'code': 200,
            'message': '更新成功',
            'data': activity.to_dict(include_organizer=True)
        })
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"更新活动失败: {str(e)}")
        return jsonify({'code': 500, 'message': '更新失败'}), 500


@activity_management_bp.route('/activities/<int:activity_id>', methods=['DELETE'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '删除活动',
    'description': '🔐 需要管理员Token认证 - 管理员删除活动',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'activity_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '活动ID'
        }
    ],
    'responses': {
        200: {
            'description': '删除活动成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '删除成功'}
                }
            }
        },
        404: {
            'description': '活动不存在',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 404},
                    'message': {'type': 'string', 'example': '活动不存在'}
                }
            }
        }
    }
})
def delete_activity(activity_id):
    """删除活动"""
    try:
        activity = Activity.query.get_or_404(activity_id)
        
        # 删除相关的参与记录
        ActivityParticipant.query.filter_by(activity_id=activity_id).delete()
        
        # 删除活动
        db.session.delete(activity)
        db.session.commit()
        
        return jsonify({
            'code': 200,
            'message': '删除成功'
        })
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"删除活动失败: {str(e)}")
        return jsonify({'code': 500, 'message': '删除失败'}), 500


@activity_management_bp.route('/activities/statistics', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '获取活动统计',
    'description': '🔐 需要管理员Token认证 - 管理员获取活动统计数据',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'start_date',
            'in': 'query',
            'type': 'string',
            'description': '统计开始日期（YYYY-MM-DD）'
        },
        {
            'name': 'end_date',
            'in': 'query',
            'type': 'string',
            'description': '统计结束日期（YYYY-MM-DD）'
        }
    ],
    'responses': {
        200: {
            'description': '获取活动参与者列表成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'activity': {
                                'type': 'object',
                                'description': '活动信息',
                                'properties': {
                                    'id': {'type': 'integer', 'description': '活动ID', 'example': 23},
                                    'title': {'type': 'string', 'description': '活动标题', 'example': '网球双打技巧训练'},
                                    'venue_name': {'type': 'string', 'description': '场馆名称', 'example': '网球场A'}
                                }
                            },
                            'participants': {
                                'type': 'array',
                                'description': '参与者列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer', 'description': '参与记录ID', 'example': 45},
                                        'user': {
                                            'type': 'object',
                                            'description': '用户信息',
                                            'properties': {
                                                'id': {'type': 'integer', 'description': '用户ID', 'example': 12},
                                                'nickname': {'type': 'string', 'description': '昵称', 'example': '张三'},
                                                'phone': {'type': 'string', 'description': '手机号', 'example': '13800138001'},
                                                'avatar_url': {'type': 'string', 'description': '头像', 'example': 'https://example.com/avatar.jpg'}
                                            }
                                        },
                                        'joined_at': {'type': 'string', 'description': '参与时间', 'example': '2025-06-16 14:30:00'},
                                        'status': {'type': 'string', 'description': '参与状态', 'example': 'joined'}
                                    }
                                }
                            },
                            'participant_count': {'type': 'integer', 'description': '参与人数统计', 'example': 8}
                        }
                    }
                }
            },
            'examples': {
                'application/json': {
                    'code': 200,
                    'message': '获取成功',
                    'data': {
                        'activity': {
                            'id': 23,
                            'title': '网球双打技巧训练',
                            'venue_name': '网球场A'
                        },
                        'participants': [
                            {
                                'id': 45,
                                'user': {
                                    'id': 12,
                                    'nickname': '张三',
                                    'phone': '13800138001',
                                    'avatar_url': 'https://example.com/avatar.jpg'
                                },
                                'joined_at': '2025-06-16 14:30:00',
                                'status': 'joined'
                            }
                        ],
                        'participant_count': 8
                    }
                }
            }
        }
    }
})
def get_activity_statistics():
    """获取活动统计"""
    try:
        start_date = request.args.get('start_date')
        end_date = request.args.get('end_date')
        
        # 基础查询
        query = Activity.query
        
        # 时间范围筛选
        if start_date:
            try:
                start_datetime = datetime.strptime(start_date, '%Y-%m-%d')
                query = query.filter(Activity.created_at >= start_datetime)
            except ValueError:
                pass
        
        if end_date:
            try:
                end_datetime = datetime.strptime(end_date, '%Y-%m-%d') + timedelta(days=1)
                query = query.filter(Activity.created_at < end_datetime)
            except ValueError:
                pass
        
        # 总体统计
        total_activities = query.count()
        open_activities = query.filter_by(status='open').count()
        closed_activities = query.filter_by(status='closed').count()
        cancelled_activities = query.filter_by(status='cancelled').count()
        
        # 参与人数统计
        participant_stats = db.session.query(
            func.sum(Activity.current_participants).label('total_participants')
        ).filter(Activity.id.in_([a.id for a in query.all()])).first()
        
        total_participants = participant_stats.total_participants or 0
        
        # 按场馆统计
        venue_stats = db.session.query(
            Venue.name,
            func.count(Activity.id).label('activity_count')
        ).join(Activity, Venue.id == Activity.venue_id)\
         .filter(Activity.id.in_([a.id for a in query.all()]))\
         .group_by(Venue.id, Venue.name)\
         .order_by(func.count(Activity.id).desc())\
         .limit(10).all()
        
        # 按月统计（最近6个月）
        monthly_stats = []
        for i in range(6):
            month_start = datetime.now().replace(day=1) - timedelta(days=i*30)
            month_end = month_start + timedelta(days=30)
            
            month_count = Activity.query.filter(
                and_(
                    Activity.created_at >= month_start,
                    Activity.created_at < month_end
                )
            ).count()
            
            monthly_stats.insert(0, {
                'month': month_start.strftime('%Y-%m'),
                'count': month_count
            })
        
        statistics = {
            'overview': {
                'total_activities': total_activities,
                'open_activities': open_activities,
                'closed_activities': closed_activities,
                'cancelled_activities': cancelled_activities,
                'total_participants': total_participants
            },
            'venue_stats': [
                {'venue_name': stat.name, 'activity_count': stat.activity_count}
                for stat in venue_stats
            ],
            'monthly_stats': monthly_stats
        }
        
        return jsonify({
            'code': 200,
            'message': '获取成功',
            'data': statistics
        })
        
    except Exception as e:
        current_app.logger.error(f"获取活动统计失败: {str(e)}")
        return jsonify({'code': 500, 'message': '获取失败'}), 500


@activity_management_bp.route('/activities/<int:activity_id>/participants', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '获取活动参与者列表',
    'description': '🔐 需要管理员Token认证 - 管理员获取指定活动的参与者列表',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'activity_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '活动ID'
        }
    ],
    'responses': {
        200: {
            'description': '获取活动参与者列表成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'activity': {
                                'type': 'object',
                                'description': '活动信息',
                                'properties': {
                                    'id': {'type': 'integer', 'description': '活动ID', 'example': 23},
                                    'title': {'type': 'string', 'description': '活动标题', 'example': '网球双打技巧训练'},
                                    'venue_name': {'type': 'string', 'description': '场馆名称', 'example': '网球场A'}
                                }
                            },
                            'participants': {
                                'type': 'array',
                                'description': '参与者列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer', 'description': '参与记录ID', 'example': 45},
                                        'user': {
                                            'type': 'object',
                                            'description': '用户信息',
                                            'properties': {
                                                'id': {'type': 'integer', 'description': '用户ID', 'example': 12},
                                                'nickname': {'type': 'string', 'description': '昵称', 'example': '张三'},
                                                'phone': {'type': 'string', 'description': '手机号', 'example': '13800138001'},
                                                'avatar_url': {'type': 'string', 'description': '头像', 'example': 'https://example.com/avatar.jpg'}
                                            }
                                        },
                                        'joined_at': {'type': 'string', 'description': '参与时间', 'example': '2025-06-16 14:30:00'},
                                        'status': {'type': 'string', 'description': '参与状态', 'example': 'joined'}
                                    }
                                }
                            },
                            'participant_count': {'type': 'integer', 'description': '参与人数统计', 'example': 8}
                        }
                    }
                }
            },
            'examples': {
                'application/json': {
                    'code': 200,
                    'message': '获取成功',
                    'data': {
                        'activity': {
                            'id': 23,
                            'title': '网球双打技巧训练',
                            'venue_name': '网球场A'
                        },
                        'participants': [
                            {
                                'id': 45,
                                'user': {
                                    'id': 12,
                                    'nickname': '张三',
                                    'phone': '13800138001',
                                    'avatar_url': 'https://example.com/avatar.jpg'
                                },
                                'joined_at': '2025-06-16 14:30:00',
                                'status': 'joined'
                            }
                        ],
                        'participant_count': 8
                    }
                }
            }
        }
    }
})
def get_activity_participants(activity_id):
    """获取活动参与者列表"""
    try:
        activity = Activity.query.get_or_404(activity_id)
        
        participants = []
        for participant in ActivityParticipant.query.filter_by(
            activity_id=activity_id, status='joined'
        ).all():
            if participant.user:
                participant_data = {
                    'id': participant.id,
                    'user': participant.user.to_dict(),
                    'joined_at': participant.joined_at.strftime('%Y-%m-%d %H:%M:%S') if participant.joined_at else None,
                    'status': participant.status
                }
                participants.append(participant_data)
        
        return success_response({
            'activity': activity.to_dict(),
            'participants': participants,
            'participant_count': len(participants)
        }, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取活动参与者失败: {str(e)}")
        return error_response('获取失败', 500)


@activity_management_bp.route('/users/search', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '搜索用户',
    'description': '🔐 需要管理员Token认证 - 管理员搜索用户，用于选择活动组织者。如果关键词为空，则返回最近注册的用户。',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'keyword',
            'in': 'query',
            'type': 'string',
            'required': False,
            'description': '搜索关键词（昵称或手机号），如果为空则返回最近的用户'
        },
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 20,
            'description': '每页数量'
        }
    ],
    'responses': {
        200: {
            'description': '搜索成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '搜索成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'users': {
                                'type': 'array',
                                'description': '搜索到的用户列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer', 'description': '用户ID', 'example': 12},
                                        'nickname': {'type': 'string', 'description': '用户昵称', 'example': '张三'},
                                        'phone': {'type': 'string', 'description': '手机号', 'example': '13800138001'},
                                        'avatar_url': {'type': 'string', 'description': '头像URL', 'example': 'https://example.com/avatar.jpg'},
                                        'created_at': {'type': 'string', 'description': '注册时间', 'example': '2025-06-01 10:00:00'}
                                    }
                                }
                            },
                            'total': {'type': 'integer', 'description': '搜索结果总数', 'example': 15},
                            'page': {'type': 'integer', 'description': '当前页码', 'example': 1},
                            'per_page': {'type': 'integer', 'description': '每页数量', 'example': 20},
                            'pages': {'type': 'integer', 'description': '总页数', 'example': 1}
                        }
                    }
                }
            }
        }
    }
})
def search_users():
    """管理员搜索用户"""
    try:
        keyword = request.args.get('keyword', '').strip()
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 20, type=int), 100)

        query = User.query.filter(User.is_active == True)

        if keyword:
            query = query.filter(
                or_(
                    User.nickname.ilike(f'%{keyword}%'),
                    User.phone.ilike(f'%{keyword}%')
                )
            )
        
        query = query.order_by(User.created_at.desc())
        
        pagination = query.paginate(page=page, per_page=per_page, error_out=False)
        users = [user.to_dict() for user in pagination.items]

        return success_response({
            'users': users,
            'total': pagination.total,
            'page': page,
            'per_page': per_page,
            'pages': pagination.pages
        })
    except Exception as e:
        current_app.logger.error(f"搜索用户失败: {str(e)}")
        return error_response('搜索失败', 500)


@activity_management_bp.route('/activities/<int:activity_id>/generate-order', methods=['POST'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '为活动生成订单',
    'description': '🔐 需要管理员Token认证 - 管理员为指定活动生成订单，检查时间冲突并计算金额',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'activity_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '活动ID'
        }
    ],
    'responses': {
        200: {
            'description': '订单生成成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '订单生成成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'order_id': {'type': 'integer', 'description': '订单ID', 'example': 123},
                            'order_no': {'type': 'string', 'description': '订单号', 'example': 'ACT1703123456'},
                            'amount': {'type': 'number', 'description': '订单金额', 'example': 100.0},
                            'activity_id': {'type': 'integer', 'description': '活动ID', 'example': 23},
                            'activity_title': {'type': 'string', 'description': '活动标题', 'example': '网球双打技巧训练'},
                            'venue_name': {'type': 'string', 'description': '场馆名称', 'example': '网球场A'},
                            'booking_date': {'type': 'string', 'description': '预订日期', 'example': '2025-06-25'},
                            'time_slot': {'type': 'string', 'description': '时间段', 'example': '10:00-12:00'},
                            'status': {'type': 'integer', 'description': '订单状态', 'example': 0}
                        }
                    }
                }
            }
        },
        400: {
            'description': '生成订单失败',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 400},
                    'message': {'type': 'string', 'example': '该时间段已有订单，无法重复预订'}
                }
            }
        },
        404: {
            'description': '活动不存在',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 404},
                    'message': {'type': 'string', 'example': '活动不存在'}
                }
            }
        },
        500: {
            'description': '服务器内部错误',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 500},
                    'message': {'type': 'string', 'example': '生成订单失败'}
                }
            }
        }
    }
})
def generate_order_for_activity(activity_id):
    """为活动生成订单 - 增强版本，包含冲突检查和金额计算"""
    try:
        current_app.logger.info(f"开始为活动 {activity_id} 生成订单")
        
        # 获取活动信息
        activity = Activity.query.get_or_404(activity_id)
        current_app.logger.info(f"活动信息: {activity.title}, 状态: {activity.status}")
        
        # 检查活动状态
        if activity.status != 'open':
            current_app.logger.warning(f"活动状态不是open: {activity.status}")
            return error_response('只有开放中的活动才能生成订单', 400)
        
        # 获取当前管理员ID
        current_admin_id = get_jwt_identity()
        current_app.logger.info(f"JWT身份: {current_admin_id}")
        
        if not current_admin_id:
            current_app.logger.error("无法获取管理员身份")
            return error_response('无法获取管理员身份', 401)
        
        # 转换为整数
        try:
            current_admin_id = int(current_admin_id)
            current_app.logger.info(f"管理员ID转换成功: {current_admin_id}")
        except (ValueError, TypeError) as e:
            current_app.logger.error(f"管理员ID转换失败: {e}")
            return error_response('管理员身份无效', 401)
        
        # 检查活动是否有关联的场馆
        if not activity.venue_id:
            current_app.logger.error("活动没有关联场馆")
            return error_response('活动没有关联场馆，无法生成订单', 400)
            
        venue = Venue.query.get(activity.venue_id)
        if not venue or venue.status != 1:
            current_app.logger.error(f"场馆不存在或已关闭: {activity.venue_id}")
            return error_response('活动关联的场馆不可用', 400)
        
        # 检查活动是否有照片，如果没有则根据场地类型设置默认照片
        import json
        try:
            activity_images = json.loads(activity.images) if activity.images else []
        except (json.JSONDecodeError, TypeError):
            activity_images = []
        
        # 如果活动没有图片，根据场地类型设置默认图片
        if not activity_images:
            default_images = []
            if venue.type == 'football':
                default_images = ['/uploads/activity/106a49c4-1598-4ae5-a018-5b29408ef65e.jpeg']
                current_app.logger.info(f"活动 {activity_id} 没有图片，设置足球场默认图片")
            elif venue.type == 'basketball':
                default_images = ['/uploads/activity/1e03ccbc-0427-46ac-99c5-0ea833be3d94.jpg']
                current_app.logger.info(f"活动 {activity_id} 没有图片，设置篮球场默认图片")
            elif venue.type == 'tennis':
                default_images = ['/uploads/activity/106a49c4-1598-4ae5-a018-5b29408ef65e.jpeg']
                current_app.logger.info(f"活动 {activity_id} 没有图片，设置网球场默认图片")
            elif venue.type == 'badminton':
                default_images = ['/uploads/activity/106a49c4-1598-4ae5-a018-5b29408ef65e.jpeg']
                current_app.logger.info(f"活动 {activity_id} 没有图片，设置羽毛球场默认图片")
            else:
                default_images = ['/uploads/activity/106a49c4-1598-4ae5-a018-5b29408ef65e.jpeg']
                current_app.logger.info(f"活动 {activity_id} 没有图片，设置通用场馆默认图片")
            
            if default_images:
                # 更新活动图片
                activity.images = json.dumps(default_images)
                current_app.logger.info(f"为活动 {activity_id} 设置默认图片: {default_images}")
        
        # 获取活动时间信息
        if not activity.start_time or not activity.end_time:
            current_app.logger.error("活动缺少时间信息")
            return error_response('活动缺少时间信息', 400)
            
        # 计算活动日期和时间
        activity_date = activity.start_time.date()
        activity_start_time = activity.start_time.replace(second=0, microsecond=0).time()
        activity_end_time = activity.end_time.replace(second=0, microsecond=0).time()
        
        current_app.logger.info(f"活动时间: {activity_date} {activity_start_time}-{activity_end_time}")
        
        # 检查是否存在时间冲突的订单
        existing_orders_count = Order.query.filter(
            Order.venue_id == venue.id,
            Order.reservation_date == activity_date,
            Order.status.in_([0, 1, 3])  # 未支付、已支付、已完成的订单都算冲突
        ).count()
        
        if existing_orders_count > 0:
            current_app.logger.warning(f"该场地在 {activity_date} 已有 {existing_orders_count} 个订单")
            return error_response('该场地在活动日期已有订单，无法重复预订', 400)
        
        current_app.logger.info("通过冲突检查，可以创建订单")
        
        # 获取场地在活动时间段内的所有时间段并计算总金额
        weekday = activity_date.weekday() + 1  # Python的weekday()返回0-6，数据库存储1-7
        
        try:
            # 查找该场馆在该星期几且与活动时间重叠的时间段
            from datetime import time
            
            # 将活动时间转换为字符串格式用于比较
            activity_start_str = activity_start_time.strftime('%H:%M')
            activity_end_str = activity_end_time.strftime('%H:%M')
            
            current_app.logger.info(f"查找活动时间段：{activity_start_str} - {activity_end_str}")
            
            # 查询与活动时间重叠的时间段
            result = db.session.execute(
                text("""
                    SELECT id, start_time, end_time, price 
                    FROM venue_time_slots 
                    WHERE venue_id = :venue_id 
                    AND day_of_week = :weekday 
                    AND status = 1
                    AND (
                        (start_time <= :activity_start AND end_time > :activity_start) OR
                        (start_time < :activity_end AND end_time >= :activity_end) OR
                        (start_time >= :activity_start AND end_time <= :activity_end)
                    )
                    ORDER BY start_time
                """),
                {
                    "venue_id": venue.id, 
                    "weekday": weekday,
                    "activity_start": activity_start_str,
                    "activity_end": activity_end_str
                }
            ).fetchall()
            
            if result:
                # 计算重叠时间段的总金额
                total_amount = 0.0
                time_slot_ids = []
                
                for row in result:
                    slot_id, slot_start, slot_end, slot_price = row
                    time_slot_ids.append(slot_id)
                    total_amount += float(slot_price)
                    current_app.logger.info(f"包含时间段: {slot_start}-{slot_end}, 价格: {slot_price}")
                
                time_slot_id = time_slot_ids[0] if time_slot_ids else None  # 使用第一个时间段的ID
                current_app.logger.info(f"找到 {len(result)} 个重叠时间段，总金额: {total_amount}")
                
                # 如果找不到重叠的时间段，查找最接近的时间段
                if total_amount == 0:
                    current_app.logger.warning("未找到重叠时间段，查找最接近的时间段")
                    fallback_result = db.session.execute(
                        text("SELECT id, price FROM venue_time_slots WHERE venue_id = :venue_id AND day_of_week = :weekday AND status = 1 ORDER BY start_time LIMIT 1"),
                        {"venue_id": venue.id, "weekday": weekday}
                    ).fetchone()
                    
                    if fallback_result:
                        time_slot_id = fallback_result[0]
                        total_amount = float(fallback_result[1])
                        current_app.logger.info(f"使用最接近的时间段，金额: {total_amount}")
            else:
                # 未找到任何时间段，使用默认值
                total_amount = 100.0
                time_slot_id = 20
                current_app.logger.info(f"未找到任何时间段，使用默认金额: {total_amount}")
                
        except Exception as e:
            current_app.logger.error(f"查询时间段失败: {e}")
            # 回退到固定金额
            total_amount = 100.0
            time_slot_id = 20
        
        # 生成订单号
        order_no = f"ACT{int(time.time())}{activity_id:04d}"
        current_app.logger.info(f"生成订单号: {order_no}")
        
        # 创建订单
        from datetime import datetime
        now = datetime.now().replace(microsecond=0)  # 去除微秒
        
        order = Order(
            order_no=order_no,
            user_id=current_admin_id,
            venue_id=venue.id,
            time_slot_id=time_slot_id,
            reservation_date=activity_date,
            start_time=activity_start_time,
            end_time=activity_end_time,
            amount=total_amount,
            status=0,  # 0-未支付状态
            remark=f"活动订单: {activity.title}",
            created_at=now,
            updated_at=now
        )
        
        current_app.logger.info("订单对象创建成功，准备保存")
        
        # 保存订单到数据库，同时保存活动的图片更新
        db.session.add(order)
        db.session.commit()
        current_app.logger.info(f"订单保存成功，订单号: {order_no}")
        current_app.logger.info(f"活动信息已同步更新")
        
        # 返回成功响应（简化版本）
        return success_response({
            'order_no': order_no,
            'amount': total_amount,
            'activity_id': activity_id,
            'activity_title': activity.title,
            'venue_name': venue.name,
            'booking_date': activity_date.strftime('%Y-%m-%d'),
            'time_slot': f"{activity_start_time.strftime('%H:%M')}-{activity_end_time.strftime('%H:%M')}",
            'status': 0,
            'payment_required': True,
            'conflict_check_passed': True,
            'message': '订单已成功创建，请及时支付'
        }, '订单生成成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"生成订单失败: {str(e)}")
        current_app.logger.error(f"错误类型: {type(e)}")
        import traceback
        current_app.logger.error(f"错误堆栈: {traceback.format_exc()}")
        return error_response('生成订单失败', 500)


@activity_management_bp.route('/activities/<int:activity_id>/order', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '获取活动订单信息',
    'description': '🔐 需要管理员Token认证 - 获取指定活动的订单信息，包括订单详情和付款状态',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'activity_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '活动ID'
        }
    ],
    'responses': {
        200: {
            'description': '获取活动订单信息成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'has_order': {'type': 'boolean', 'description': '是否有订单'},
                            'order': {
                                'type': 'object',
                                'description': '订单详情',
                                'properties': {
                                    'order_no': {'type': 'string', 'description': '订单号'},
                                    'amount': {'type': 'number', 'description': '订单金额'},
                                    'status': {'type': 'integer', 'description': '订单状态'},
                                    'status_text': {'type': 'string', 'description': '状态文本'},
                                    'created_at': {'type': 'string', 'description': '创建时间'},
                                    'payment_required': {'type': 'boolean', 'description': '是否需要付款'}
                                }
                            },
                            'activity': {
                                'type': 'object',
                                'description': '活动信息',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'title': {'type': 'string'},
                                    'venue_name': {'type': 'string'}
                                }
                            }
                        }
                    }
                }
            }
        },
        404: {
            'description': '活动不存在',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 404},
                    'message': {'type': 'string', 'example': '活动不存在'}
                }
            }
        }
    }
})
def get_activity_order(activity_id):
    """获取活动订单信息"""
    try:
        current_app.logger.info(f"获取活动 {activity_id} 的订单信息")
        
        # 获取活动信息
        activity = Activity.query.get_or_404(activity_id)
        
        # 获取活动对应的订单（使用原生SQL避免时间字段问题）
        from sqlalchemy import text
        
        # 查询活动对应的订单
        order_result = db.session.execute(
            text("""
                SELECT o.order_no, o.amount, o.status, o.created_at, v.name as venue_name
                FROM orders o
                JOIN venues v ON o.venue_id = v.id
                WHERE o.venue_id = :venue_id 
                AND o.reservation_date = DATE(:activity_date)
                ORDER BY o.created_at DESC
                LIMIT 1
            """),
            {
                'venue_id': activity.venue_id,
                'activity_date': activity.start_time.date() if activity.start_time else None
            }
        ).fetchone()
        
        if order_result:
            # 有订单
            status_map = {0: '未支付', 1: '已支付', 2: '已取消', 3: '已完成', 4: '已退款'}
            order_data = {
                'order_no': order_result[0],
                'amount': float(order_result[1]),
                'status': order_result[2],
                'status_text': status_map.get(order_result[2], '未知状态'),
                'created_at': str(order_result[3]),
                'payment_required': order_result[2] == 0,  # 未支付状态需要付款
                'is_paid': order_result[2] in [1, 3],  # 已支付或已完成
                'can_generate': False  # 已有订单，不能再生成
            }
            
            return success_response({
                'has_order': True,
                'order': order_data,
                'activity': {
                    'id': activity.id,
                    'title': activity.title,
                    'venue_name': order_result[4]
                }
            }, '获取成功')
        else:
            # 没有订单
            venue = Venue.query.get(activity.venue_id) if activity.venue_id else None
            return success_response({
                'has_order': False,
                'order': None,
                'activity': {
                    'id': activity.id,
                    'title': activity.title,
                    'venue_name': venue.name if venue else '未知场馆'
                },
                'can_generate': True  # 没有订单，可以生成
            }, '获取成功')
            
    except Exception as e:
        current_app.logger.error(f"获取活动订单失败: {str(e)}")
        return error_response('获取活动订单失败', 500)



@activity_management_bp.route('/activities/<int:activity_id>/waitlist', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['活动管理'],
    'summary': '获取活动候补名单',
    'description': '🔐 需要管理员Token认证 - 管理员获取指定活动的候补名单，包括候补用户详细信息和排队位置。',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'activity_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '活动ID'
        },
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 20,
            'description': '每页数量'
        }
    ],
    'responses': {
        200: {
            'description': '获取候补名单成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'activity': {
                                'type': 'object',
                                'description': '活动信息',
                                'properties': {
                                    'id': {'type': 'integer', 'description': '活动ID', 'example': 23},
                                    'title': {'type': 'string', 'description': '活动标题', 'example': '网球双打技巧训练'},
                                    'venue_name': {'type': 'string', 'description': '场馆名称', 'example': '网球场A'},
                                    'current_participants': {'type': 'integer', 'description': '当前参与人数', 'example': 15},
                                    'max_participants': {'type': 'integer', 'description': '最大参与人数', 'example': 20},
                                    'allow_waitlist': {'type': 'boolean', 'description': '是否允许候补', 'example': True}
                                }
                            },
                            'waitlist_participants': {
                                'type': 'array',
                                'description': '候补用户列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer', 'description': '参与记录ID', 'example': 45},
                                        'user': {
                                            'type': 'object',
                                            'description': '用户信息',
                                            'properties': {
                                                'id': {'type': 'integer', 'description': '用户ID', 'example': 12},
                                                'nickname': {'type': 'string', 'description': '昵称', 'example': '张三'},
                                                'phone': {'type': 'string', 'description': '手机号', 'example': '13800138001'},
                                                'avatar_url': {'type': 'string', 'description': '头像', 'example': 'https://example.com/avatar.jpg'}
                                            }
                                        },
                                        'joined_at': {'type': 'string', 'description': '加入候补时间', 'example': '2025-01-06 14:30:00'},
                                        'waitlist_position': {'type': 'integer', 'description': '候补排队位置', 'example': 1},
                                        'status': {'type': 'string', 'description': '状态', 'example': 'waitlist'}
                                    }
                                }
                            },
                            'total': {'type': 'integer', 'description': '候补总人数', 'example': 5},
                            'page': {'type': 'integer', 'description': '当前页码', 'example': 1},
                            'pages': {'type': 'integer', 'description': '总页数', 'example': 1},
                            'per_page': {'type': 'integer', 'description': '每页数量', 'example': 20}
                        }
                    }
                }
            },
            'examples': {
                'application/json': {
                    'code': 200,
                    'message': '获取成功',
                    'data': {
                        'activity': {
                            'id': 23,
                            'title': '网球双打技巧训练',
                            'venue_name': '网球场A',
                            'current_participants': 15,
                            'max_participants': 20,
                            'allow_waitlist': True
                        },
                        'waitlist_participants': [
                            {
                                'id': 45,
                                'user': {
                                    'id': 12,
                                    'nickname': '张三',
                                    'phone': '13800138001',
                                    'avatar_url': 'https://example.com/avatar.jpg'
                                },
                                'joined_at': '2025-01-06 14:30:00',
                                'waitlist_position': 1,
                                'status': 'waitlist'
                            }
                        ],
                        'total': 5,
                        'page': 1,
                        'pages': 1,
                        'per_page': 20
                    }
                }
            }
        },
        404: {
            'description': '活动不存在',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 404},
                    'message': {'type': 'string', 'example': '活动不存在'}
                }
            }
        }
    }
})
def get_activity_waitlist_admin(activity_id):
    """管理员获取活动候补名单"""
    try:
        # 检查活动是否存在
        activity = Activity.query.get(activity_id)
        if not activity or not activity.is_active:
            return error_response('活动不存在', 404)
        
        # 获取分页参数
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 20, type=int), 100)
        
        # 获取候补用户列表（按加入时间排序）
        waitlist_query = ActivityParticipant.query.filter_by(
            activity_id=activity_id,
            status='waitlist'
        ).order_by(ActivityParticipant.created_at.asc())
        
        # 分页查询
        pagination = waitlist_query.paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        # 构建候补用户列表
        waitlist_participants = []
        for index, participant in enumerate(pagination.items):
            # 计算排队位置（考虑分页）
            waitlist_position = (page - 1) * per_page + index + 1
            
            waitlist_participants.append({
                'id': participant.id,
                'user': {
                    'id': participant.user.id,
                    'nickname': participant.user.nickname,
                    'phone': participant.user.phone,
                    'avatar_url': participant.user.avatar_url
                },
                'joined_at': participant.created_at.strftime('%Y-%m-%d %H:%M:%S'),
                'waitlist_position': waitlist_position,
                'status': participant.status
            })
        
        # 获取活动基本信息
        activity_info = {
            'id': activity.id,
            'title': activity.title,
            'venue_name': activity.venue.name if activity.venue else '未指定场馆',
            'current_participants': activity.current_participants,
            'max_participants': activity.max_participants,
            'allow_waitlist': activity.allow_waitlist
        }
        
        response_data = {
            'activity': activity_info,
            'waitlist_participants': waitlist_participants,
            'total': pagination.total,
            'page': page,
            'pages': pagination.pages,
            'per_page': per_page
        }
        
        return success_response(response_data, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取候补名单失败: {str(e)}")
        return error_response('获取失败', 500)
